;void recortar_asm (
;	unsigned char *src,		RDI (DIL)
;	unsigned char *dst,		RSI (SIL)
;	int m,					RDX	(EDX)
;	int n,					RCX	(ECX)
;	int src_row_size,		R8	(R8D)
;	int dst_row_size,		R9	(R9D)
;	int x,					rbp+16
;	int y,					rbp+24
;	int tam					rbp+32
;);


%define tam [rbp +32]
%define x [rbp+16]
%define y [rbp+24]
%define padding r15


global recortar_asm

recortar_asm:
	;; TODO: Implementar
	push rbp
	mov rbp, rsp
	push r12
	push r13
	push r14
	push r15
	
	xor r15, r15		;Obtengo el valor de Padding
	mov r15d, r9d
	sub r15d, tam
					;OBTENGO LA CANTIDAD DE CICLOS DE A 16 Y DE A 1
	push rdx
	mov r13, 16		;Muevo 16 a r13
	xor rax, rax	;limpio rax y rdx
	xor rdx, rdx
	mov eax, tam	;Muevo a EAX "tam"
	idiv r13		;en RAX tengo la cantidad de veces que cicla Columna Coeficiente
					;en RDX tengo el resto, la cantidad de elementos que no se pueden operar de a 16
	mov r13, rdx	;r13 = ciclos de a 1
	mov r12d, tam
	sub r12, r13	;En R12 tengo la cantidad de pixeles a procesar de a 16.
	pop rdx



	
	xor r10, r10
	mov r10d, y		;pongo y
	xor rax, rax
	mov eax, r8d;r8d	;pongo row_size en EAX
	mul r10			;multiplico y*n
	mov r10, rax
	add r10d, x		;Le sumo x
	add r10, rdi	;le sumo src => r10 = src[x+(y*n)]
	
	xor rcx, rcx
	mov ecx, tam	;Me guardo el Tamaño en RCX

	xor r14, r14
.cicloF:
	xor r11, r11
	
	.cicloC:
		movdqu xmm0, [r10]	
		movdqu [rsi], xmm0	;Copio 16 bytes
		add rsi, 16			;sumo 16 bytes a dst (los q acabo de copiar)
		add r10, 16			;sumo 16 a src
		add r11, 16			;sumo 16 bytes al contador
		cmp r11, r12		;si llegue a tam salgo del ciclo
		jne .cicloC
						;Si termine con los de a 16 sigo de a 1
		xor r11, r11	;Muevo a r11 el contador de pixeles de a 1.
	
	.deAUno:
		cmp r13, 0
		je .continuo
		mov al, [r10]
		mov [rsi], al
		add rsi, 1
		add r10, 1
		add r11, 1
		cmp r11, r13	;Si r11 es igual a la cantidad de elementos q no podia procesar de a 1
		jne .deAUno

.continuo:
	add r10, r8				;
	sub r10, rcx	;A src le sumo (src_row_size - tam) para ponerlo al ppio de la imagen que tengo que pasar en la linea que sigue.
	add r14, 1	
	add rsi, padding	;le sumo el padding
	cmp r14, rcx		;Si es igual al tamaño salto.
	jne .cicloF
	
	pop r15
	pop r14
	pop r13
	pop r12
	pop rbp
	ret
	
	
	
	
	
